package com.zp.self.module.level_4_算法练习.算法.动态规划;

/**
 * @author By ZengPeng
 */
public class 力扣_213_打家劫舍II {
    //测试
    public static void main(String[] args) {

        System.out.println(new 力扣_213_打家劫舍II().maxProfit(new int[]{2,3,2}));
        System.out.println(new 力扣_213_打家劫舍II().maxProfit(new int[]{1,2,3,1}));
        System.out.println(new 力扣_213_打家劫舍II().maxProfit(new int[]{1,2,3}));
    }

    /**
    题目：你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。
     这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。
     同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
     给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

     示例 1：
     输入：nums = [2,3,2]
     输出：3
     解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

     示例 2：
     输入：nums = [1,2,3,1]
     输出：4
     解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
          偷窃到的最高金额 = 1 + 3 = 4 。

     示例 3：
     输入：nums = [1,2,3]
     输出：3

    分析：【P 💜💜💜💜💜】
       1.动态规划：将问题拆分成[0,n-2]中找不连续最大值，与[1,n-1]中找不连续最大值
                 fn = Math.max(nums[n] + fn-2  ,  fn-1)
                 f3 = Math.max(numb[3] + f1  , f2)
                 f2 = Math.max(numb[2] + f0  , f1)
                 f1 = Math.max(numb[1]  , numb[0])
                 f0 = numb[0]
                --执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户

    边界值 & 注意点：
       1.
     **/
    public int maxProfit(int[] nums) {
        if(nums.length==1)return  nums[0];
        if(nums.length==2)return  Math.max(nums[0],nums[1]);
        int proPro = nums[0],pro = Math.max(nums[0],nums[1]),index=2,current=pro;
        while (index<nums.length-1){
            current = Math.max(pro,nums[index]+proPro);
            proPro=pro;
            pro=current;
            index++;
        }
        proPro = nums[1];
        pro = Math.max(nums[1],nums[2]);
        index=3;
        int current2=pro;
        while (index<nums.length){
            current2 = Math.max(pro,nums[index]+proPro);
            proPro=pro;
            pro=current2;
            index++;
        }
        return Math.max(current2,current);
    }
}
